#数组的创建
ary1=[1,2,3] # [1,2,3]
ary1=Array.new #=> []
ary1=Array.new(3) #=>[nil, nil, nil]
ary1=Array.new(3,"a") #=>["a", "a", "a"]
ary1=%w(张天泽 李立平 徐睿颉) #创建不含空格的数组["张天泽", "李立平", "徐睿颉"]
ary1=%i(Ruby C++ Java) #创建符号数组[:Ruby, :"C++", :Java],()也可以被其它成对字符替代
hash1={ztz:"张天泽",llp:"李立平"}
ary1=hash1.to_a #二维数组，to_a方法
str1="Tous pour un,un pour tous."
ary1=str1.split(/\,|\s|\./) # String类的split方法

#索引
#获取元素
a1=["a","b","c","d","e"]
=begin
a.at(n)===a[n]
a.slice(n)===a[n]
a.slice(n..m)===a[n..m]
a.slice(n,len)===a[n,len]
=end
#替换元素(索引元素前)
a2=["a","b","c","d","e"]
a2[0]="A"
a2[1..2]=["B","C"]
a2[3,3]=["D","E","F"]
#插入元素(替换0个元素)
a1[5,0]="f"
#分散索引
a1_1=a1.values_at(1,3,5)

#作为集合的数组
#交并差
b1=[1,2,4]
b2=[2,3,5]
print b1&b2,b1|b2,b1-b2,"\n" #=>[2][1, 2, 4, 3, 5][1, 4]
# "+",ary.concat()也可以直接连接数组

#作为列的数组
c1=%w(b b c d d)
c1.shift #删除开头
c1.pop #删除结尾
c1.unshift("a") #追加开头
c1.push("f") #追加结尾
# c1<<"f"
print c1.first,c1.last,c1,"\n"

#方法
=begin
破坏性的方法：直接替换原来的值，而不是返回新的数组
如：pop,shift,concat,同名方法后加!区分
=end
d1=[1,2,3,4]
d1.freeze #冻结，禁止破坏性方法
begin
    d1.pop
rescue => exception
    p exception.message
ensure
    d2=d1.dup #产生冻结的副本
    p d2.pop
end
#删除元素
=begin
a.compact/a.compact! 删除nil
a.delete(x) 删除x元素
a.delete_at(n) 删除a[n]
a.delete_if{|item| ...}(破坏性)
a.reject{|item| ...}
a.reject!{|item| ...} 块为真删除item
a.slice!() 删除
a.uniq/a.uniq! 删除重复
a.shift a.pop
=end
#替换元素
=begin
a.collect{|item| ...}
a.collect!{|item| ...}
a.map{|item| ...}
a.map!{|item| ...} 块处理后的数组
a.fill(value)
a.fill(value,begin)
a.fill(value,begin,len)
a.fill(value,n..m) 全替换
a.flatten/a.flatten! 平坦化，展开嵌套数组
a.reverse/a.reverse! 反转
a.sort/a.sort!
a.sort{|i,j| ...}
a.sort!{|i,j| ...} 排序，由块指定，否则使用<=>运算符比较
a.sort_by{|i| ...} 排序，依据块结果
=end

#处理数组
#循环，索引
# each方法/ a.each_with_index{|item,i| ...}
#破坏性方法
#迭代器

#数组的元素
#多维数组
#初始化
e1=Array.new(3,[0,0,0])
e2=Array.new(3){[0,0,0]}
e1[0][1]=1
e2[0][1]=1
p e1,e2
#多个数组
f1=[1,2,3]
f2=[10,20,30]
f3=[100,200,300]
f_s=[]
f1.zip(f2,f3){|a,b,c| # zip方法
    f_s<<a+b+c
}
p f_s

# Enumerable模块
=begin
all? => 全为真返回true,否则false
any? => 存在真返回true,否则false
collect => 将各元素块执行结果以数组返回
count => 返回使用元素的数量,指定参数时返回与参数一样的
cycle => 无限循环执行块处理
detect => 块处理,结果为真时返回首个元素
each_slice => 指定参数n,n个元素为一组传递给块
each_with_index
find => 同detect
find_all => 返回数组
first
grep => 匹配参数指定的模式,返回数组
include? => 包含参数的值返回true
inject => 对元素进行块的叠加运算并返回结果
map => 同collect
member? => 同include?
none? => 全为假返回true
one? => 只有一个真返回true
partition => 依据块结果真假返回两个数组
reduce => 同inject
reverse_each => 倒each
select => 同find_all
sort => 依据块结果排序
sort_by => 依据块结果<=>后排序
to_a => 所有元素以数组返回
zip => 把接受者和参数对应的各元素合并为一个后用数组返回
=end
